const math/big._W
92 uses
math/big (current package)
arith.go#L22: _S = _W / 8 // word size in bytes
arith.go#L24: _W = bits.UintSize // word size in bits
arith.go#L25: _B = 1 << _W // digit base
arith.go#L210: s &= _W - 1 // hint to the compiler that shifts by s don't need guard code
arith.go#L211: ŝ := _W - s
arith.go#L212: ŝ &= _W - 1 // ditto
arith.go#L233: s &= _W - 1 // hint to the compiler that shifts by s don't need guard code
arith.go#L234: ŝ := _W - s
arith.go#L235: ŝ &= _W - 1 // ditto
arith.go#L276: x1 = x1<<s | x0>>(_W-s)
decimal.go#L42: const maxShift = _W - 4
float.go#L221: return uint(len(x.mant))*_W - x.mant.trailingZeroBits()
float.go#L382: const msb = 1 << (_W - 1)
float.go#L414: bits := m * _W // present mantissa bits; bits > 0
float.go#L444: n := (z.prec + (_W - 1)) / _W // mantissa length in words for desired precision
float.go#L451: ntz := n*_W - z.prec // 0 <= ntz < _W
float.go#L495: const msb = 1 << (_W - 1)
float.go#L702: if debugFloat && x[i]&(1<<(_W-1)) == 0 {
float.go#L705: switch _W {
float.go#L720: if debugFloat && x[i]&(1<<(_W-1)) == 0 {
float.go#L723: switch _W {
float.go#L878: if p < 0 /* m <= 0.25 */ || p == 0 && x.mant.sticky(uint(len(x.mant))*_W-1) == 0 /* m == 0.5 */ {
float.go#L998: if p < 0 /* m <= 0.25 */ || p == 0 && x.mant.sticky(uint(len(x.mant))*_W-1) == 0 /* m == 0.5 */ {
float.go#L1103: allBits := uint(len(x.mant)) * _W
float.go#L1150: allBits := int32(len(x.mant)) * _W
float.go#L1229: ex := int64(x.exp) - int64(len(x.mant))*_W
float.go#L1230: ey := int64(y.exp) - int64(len(y.mant))*_W
float.go#L1260: z.setExpAndRound(ex+int64(len(z.mant))*_W-fnorm(z.mant), 0)
float.go#L1276: ex := int64(x.exp) - int64(len(x.mant))*_W
float.go#L1277: ey := int64(y.exp) - int64(len(y.mant))*_W
float.go#L1313: z.setExpAndRound(ex+int64(len(z.mant))*_W-fnorm(z.mant), 0)
float.go#L1350: n := int(z.prec/_W) + 1
float.go#L1372: e := int64(x.exp) - int64(y.exp) - int64(d-len(z.mant))*_W
floatconv.go#L85: exp2 := int64(len(z.mant))*_W - fnorm(z.mant)
floatmarsh.go#L31: n = int((x.prec + (_W - 1)) / _W) // required mantissa length in words for given precision
ftoa.go#L336: switch w := uint32(len(x.mant)) * _W; {
ftoa.go#L387: switch w := uint(len(x.mant)) * _W; {
int.go#L86: } else if _W == 32 && u>>32 != 0 {
int.go#L504: if _W == 32 && len(x) > 1 {
int.go#L528: if len(x.abs) <= 64/_W {
int.go#L537: return !x.neg && len(x.abs) <= 64/_W
int.go#L756: a1 = A.abs[n-1]<<h | A.abs[n-2]>>(_W-h)
int.go#L760: a2 = B.abs[n-1]<<h | B.abs[n-2]>>(_W-h)
int.go#L762: a2 = B.abs[n-2] >> (_W - h)
nat.go#L398: return i*_W + bits.Len(top)
nat.go#L414: return i*_W + uint(bits.TrailingZeros(uint(x[i])))
nat.go#L424: return i*_W + uint(bits.TrailingZeros(uint(x[i]))), true
nat.go#L450: n := m + int(s/_W)
nat.go#L452: if s %= _W; s == 0 {
nat.go#L475: n := m - int(s/_W)
nat.go#L482: if s %= _W; s == 0 {
nat.go#L492: j := int(i / _W)
nat.go#L493: m := Word(1) << (i % _W)
nat.go#L522: j := i / _W
nat.go#L527: return uint(x[j] >> (i % _W) & 1)
nat.go#L533: j := i / _W
nat.go#L546: if x[j]<<(_W-i%_W) != 0 {
nat.go#L570: w := (n + _W - 1) / _W
nat.go#L576: if n%_W != 0 {
nat.go#L577: z[len(z)-1] &= 1<<(n%_W) - 1
nat.go#L645: bitLengthOfMSW := uint(n % _W)
nat.go#L647: bitLengthOfMSW = _W
nat.go#L652: switch _W {
nat.go#L746: const mask = 1 << (_W - 1)
nat.go#L752: w := _W - int(shift)
nat.go#L776: for j := 0; j < _W; j++ {
nat.go#L864: w := int((logM + _W - 1) / _W)
nat.go#L889: mtop := int((logM - 2) / _W) // -2 because the top word of N bits is the (N-1)/W'th word.
nat.go#L891: if mbits := (logM - 1) & (_W - 1); mbits != 0 {
nat.go#L904: for j := 0; j < _W; j += n {
nat.go#L927: zz = zz.mul(stk, z, powers[yi>>(_W-n)])
nat.go#L961: for i := 1; i < _W; i <<= 1 {
nat.go#L969: zz := nat(nil).lsh(RR, uint(2*numWords*_W))
nat.go#L998: for j := 0; j < _W; j += n {
nat.go#L1005: zz = zz.montgomery(z, powers[yi>>(_W-n)], m, k0, numWords)
nat.go#L1065: if _W == 64 {
nat.go#L1156: for uint(len(z))*_W < n {
natconv.go#L176: n = _W
natconv.go#L178: n = _W / 2
natconv.go#L180: n = _W / 4
natconv.go#L271: z = z.rsh(z, uint(n-i)*uint(_W/n))
natconv.go#L321: nbits := uint(_W) // number of unprocessed bits in w
natconv.go#L337: nbits = _W
natconv.go#L346: nbits = _W - (shift - nbits)
natmul.go#L345: const D = _W / 4 // digits per chunk
prime.go#L61: switch _W {
sqrt.go#L128: z.mant = z.mant.make(int(prec2/_W) * 2)